Course: Core Java Training
Topic: Installing and Configuring IntelliJ IDEA, Eclipse, or VS Code
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
A Java development environment provides the tools required to write, compile, execute, test, and debug Java programs. Developers can use a command-line terminal, a full-featured Integrated Development Environment (IDE), or a code editor equipped with Java extensions.
IntelliJ IDEA, Eclipse IDE, and Visual Studio Code (VS Code) are widely used tools for Java development. IntelliJ IDEA and Eclipse provide comprehensive IDE features, while VS Code is a flexible code editor that gains Java development capabilities through extensions.
Choosing and configuring an appropriate environment is an important first step in learning Core Java. A properly configured environment helps developers identify errors, manage projects, execute programs, and organize source code efficiently.
The Java Development Kit is a collection of tools used to develop Java applications. It includes the Java compiler, application launcher, and other development utilities, along with the runtime components required to run Java programs.
The two important commands used to verify a Java installation are:
java -version
javac -versionThe java command displays information about the selected Java runtime, while javac displays the compiler version. A suitable JDK is necessary for compiling Java source code.
The Java Virtual Machine executes Java bytecode. It loads classes, manages memory, and provides runtime services. Compatible JVM implementations allow Java applications to run on different operating systems.
An IDE combines several development tools in a single application. It generally provides a source-code editor, project explorer, code completion, compiler integration, run configurations, debugging tools, and error reporting.
.java file.| Feature | IntelliJ IDEA | Eclipse IDE | VS Code |
|---|---|---|---|
| Type | Full-featured IDE | Full-featured IDE | Extensible code editor |
| Java support | Built-in Java development capabilities | Strong Java development support | Available through Java extensions |
| Code completion | Advanced completion and navigation | Completion and navigation tools | Provided by language extensions |
| Debugging | Integrated debugger | Integrated debugger | Java debugging through extensions |
| Project management | Java, Maven, and Gradle projects | Java and build-tool projects | Folder-based and Java project workflows |
| Customization | Plugins and IDE settings | Plugins and preferences | Extensions and editor settings |
| Best suited for | Beginners and professional developers | Learning and enterprise development | Developers who prefer a flexible editor |
Each environment can be used to learn Core Java. Beginners should select one tool, configure it correctly, and focus on Java fundamentals before spending time learning multiple IDEs.
Choose a JDK version supported by your IDE and compatible with your course or project requirements. A supported long-term support (LTS) release is often a practical choice for a new project, but the required Java version should always take priority.
Use an official or trusted JDK distribution. The following resources provide Java downloads:
Download the installer or archive appropriate for your operating system. Follow the installation instructions and note the installation directory because the IDE may need that path when configuring the project SDK.
Open a new terminal window and execute:
java -version
javac -versionIf both commands display version information, the Java launcher and compiler are available through the terminal. If the commands are not recognized, verify the installation and PATH configuration.
The JAVA_HOME environment variable identifies the JDK installation directory. The PATH variable allows the operating system to locate commands such as java and javac without requiring their full executable paths.
Windows: C:\Program Files\Java\jdk-XX
macOS: /Library/Java/JavaVirtualMachines/jdk-XX.jdk/Contents/Home
Linux: /usr/lib/jvm/jdk-XXThese are examples only. Replace the placeholder paths with the actual installation directory on your computer. The JAVA_HOME value should point to the JDK root directory rather than its bin subdirectory.
Add the JDK's bin directory to PATH if you want to run Java commands from a terminal. On Windows, use the Environment Variables settings. On macOS and Linux, the process depends on the shell and system configuration.
Preserve existing PATH entries when making changes. After updating environment variables, open a new terminal and verify the commands again.
# Windows
where java
where javac
# macOS or Linux
which java
which javacThese commands help identify the executable paths used by the terminal. An IDE can use a different JDK from the one selected by the terminal, so check the IDE's project configuration separately.
IntelliJ IDEA is a Java development environment with code completion, navigation, refactoring, project management, and integrated execution and debugging features.
Installation screens and available options may vary by operating system and product version.
CoreJavaPractice.Inside the project's source directory, create a Java class named HelloWorld and enter the following code:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello from IntelliJ IDEA!");
}
}Expected output:
Hello from IntelliJ IDEA!The Project SDK identifies the JDK used by the project. If the IDE reports an invalid SDK or the program uses an unexpected Java version, open the project structure or SDK settings and check the selected JDK and language level.
Eclipse IDE is a widely used development environment that provides Java editing, compilation, project management, debugging, and plugin support. The Eclipse IDE package for Java developers is a convenient starting point for Core Java learners.
A workspace stores Eclipse workspace information, project references, and related settings. You can use separate workspaces to organize different sets of projects.
Menu names may vary by Eclipse version. The runtime used to launch Eclipse and the JDK used by a project can be configured separately.
CoreJavaPractice.src.HelloWorld as the class name.Enter the following code:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello from Eclipse!");
}
}Expected output:
Hello from Eclipse!Open the project properties and locate the Java Compiler settings. Choose a compiler compliance level that supports the language features used by your code and is compatible with the project requirements.
Visual Studio Code is a flexible code editor that supports Java development through extensions. It is useful for learners who want a lightweight editor that can also be used for other programming languages.
Install a JDK compatible with your Java project and the Java extensions. Open a terminal and check:
java -version
javac -versionIf the commands are unavailable, verify the JDK installation and environment variables before configuring the editor.
The extension pack provides Java language support and tools for editing, running, debugging, and managing Java projects. Its included extensions may change as the product evolves.
Official guide: Java Development in VS Code.
CoreJavaPractice.Create a file named HelloWorld.java in the opened folder and enter the following code:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello from VS Code!");
}
}javac HelloWorld.java
java HelloWorldExpected output:
Hello from VS Code!If VS Code detects multiple JDKs or selects an unsuitable runtime, use the Java extension's runtime configuration options to review the installed JDKs and project settings.
For further information, see VS Code Java Project Management.
A consistent project structure makes code easier to understand, maintain, and share. A simple practice project may use the following layout:
CoreJavaPractice/
├── src/
│ └── HelloWorld.java
└── README.mdA project using packages can be organized like this:
CoreJavaPractice/
├── src/
│ └── com/
│ └── example/
│ └── HelloWorld.java
├── out/
└── README.mdWhen a class declares package com.example;, its source file should be organized under the matching package directory inside the source root. IDEs usually manage package directories when you create classes through their project tools.
Consistent formatting improves readability and makes code easier to review. IntelliJ IDEA, Eclipse, and VS Code offer formatting settings or extensions for managing code style.
For team projects, use an agreed style guide or shared formatter configuration so that code remains consistent across different development environments.
Running a program checks its behavior, while debugging helps you inspect the program's state and locate errors. All three environments provide ways to run Java applications and debug supported projects.
A run configuration defines how an application starts. Depending on the IDE, it may include the main class, JDK, working directory, program arguments, environment variables, and classpath.
public class DebugExample {
public static void main(String[] args) {
int first = 10;
int second = 5;
int total = first + second;
System.out.println("Total: " + total);
}
}Set a breakpoint on the calculation of total. Run the program in Debug mode and inspect the values of first, second, and total.
| Problem | Possible Cause | Solution |
|---|---|---|
| Java is not recognized in the terminal. | The JDK is missing or PATH is configured incorrectly. | Verify the installation and configure PATH if needed. |
| The IDE cannot find a JDK. | The JDK is not registered in the IDE. | Select the actual JDK installation directory in the IDE settings. |
| Compilation fails because of language features. | The configured compiler level is too old. | Check the required Java version and compiler settings. |
| The program runs with an unexpected Java version. | The terminal and IDE use different JDK installations. | Check the terminal executable path and project SDK. |
| The Run option is unavailable. | The file or project is not recognized as a Java application. | Check the source filename, main method, project setup, and Java support. |
| VS Code does not provide Java features. | Java extensions are missing, disabled, or still initializing. | Install or enable the Java extension pack and wait for initialization. |
| Eclipse displays errors for a simple class. | The JDK, build path, or compiler compliance settings may be incorrect. | Review installed runtimes, Java Build Path, and compiler settings. |
| IntelliJ IDEA reports an invalid SDK. | The configured JDK directory is invalid or no longer exists. | Select a valid JDK in the project SDK settings. |
| The IDE runs slowly. | System resource limits, large projects, or excessive extensions may affect performance. | Close unnecessary projects and review resource use and installed extensions. |
| A dependency cannot be resolved. | The dependency or build-tool configuration is incomplete. | Check the dependency declaration and refresh the Maven or Gradle project. |
Install a suitable JDK, run java -version and javac -version, and record the versions displayed in the terminal.
Create a Java project named JavaBasics, add a HelloWorld class, and run it. Confirm that the expected output appears in the Run window.
Create a project named EclipsePractice, configure the JDK, create a class, and run it using Run As > Java Application.
Install the Java extension pack, open a project folder, create a Java source file, and run it through the Run action or integrated terminal.
Run the same Java program in all three tools. Compare the editing experience, error messages, project organization, and debugging workflow.
Create a class in the com.practice package and run it in your chosen IDE. If comfortable, compile and execute it using the terminal as well.
Create a program that adds two numbers. Set a breakpoint, inspect the variables, and step through the calculation.
Answer: An Integrated Development Environment combines tools for writing, organizing, running, testing, and debugging code.
Answer: The JDK provides Java development tools and runtime components. An IDE provides an interface and workflow for using development tools and managing projects.
Answer: Yes. Install a compatible JDK and Java extensions to enable Java editing, project management, execution, and debugging.
Answer: A workspace stores Eclipse workspace information, project references, and related settings.
Answer: It identifies the JDK used by the project for development and compilation-related tasks according to the project configuration.
Answer: The JDK may be missing, the IDE may not have a valid JDK configured, or the project may reference a different installation.
Answer: A breakpoint pauses execution at a selected line so developers can inspect variables, the call stack, and program behavior.
Answer: Running executes the application normally. Debugging allows developers to pause execution and inspect internal program state.
Answer: The compiler, source code, dependencies, and runtime must use compatible versions to avoid unsupported language features and bytecode compatibility problems.
Answer: No. One correctly configured development environment is sufficient for learning Core Java. Other tools can be explored later.
Continue learning Java fundamentals, object-oriented programming, classes and objects, exception handling, collections, and practical application development through the JustAcademy Core Java Training Course.
You can register for a course demo to learn more about the training.
Visit the JustAcademy homepage to explore additional courses and learning resources.
Installing and configuring a Java development environment is an essential first step in Core Java programming. IntelliJ IDEA and Eclipse provide full-featured IDE workflows, while VS Code offers a flexible editor with Java capabilities enabled through extensions. All three can support learning and application development when configured with a compatible JDK.
After setting up one environment, practice creating projects, writing classes, running programs, and debugging errors. A reliable development setup makes it easier to progress to advanced Java concepts and real-world projects.
